home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / borland / jnfb88.zip / EXPWLD.ZIP / WILD.C < prev   
C/C++ Source or Header  |  1987-08-18  |  7KB  |  190 lines
  1. #include <stdio.h>
  2. #include <dir.h>            /* The stuff for fnsplit and ffblk */
  3.  
  4. /* We use a far pointer for the source so that no matter what 
  5.    memory model you use the DOS command line can be passed to 
  6.    expwild.  Because the command line resides outside of Turbo 
  7.    C's data segment, it must be passed this way.  We do not want 
  8.    the routine wild() to have to deal with far pointers, however.  
  9.    To avoid this problem we copy any file specification we are 
  10.    about to pass to wild() into a local variable.  */
  11.  
  12.  
  13. expwild (source, dest, maxsize)    /* called from setargv to */
  14.                                    /* handle any wildcard */
  15.                                    /* specifications in the */ 
  16.                                    /* command line */
  17.  
  18. char far *source;       
  19. char *dest;
  20. int maxsize;
  21.  
  22. { 
  23.   int count = 1, savecount = 1, wildcount;
  24.   char *dwrdptr,                /* destination string pointer */
  25.        wildspec[128],           /* 128 is max command line size */
  26.        *wildptr;                /* used to extract wildcard spec */
  27.   char far *swrdptr;            /* Far pointer to match source */
  28.  
  29.   swrdptr = source;             /* Initialize the source and */
  30.   dwrdptr = dest;               /* destination word pointers */
  31.  
  32. /* Move characters from the source to the destination until
  33.    we hit the end of the null-terminated string. */
  34.     
  35.   while ((*dest = *source++) != '\0') 
  36.   {
  37.  
  38. /* If the string is too big, we're done.  Exit the loop. */
  39.  
  40.     if (++count >= maxsize) break;
  41.  
  42. /* Possibly take some action based on what the character was */
  43.  
  44.     switch (*dest++)
  45.     {
  46.       case '*':
  47.       case '?':
  48.  
  49. /* We just moved a wildcard character.  Move back in the source to 
  50.    the start of the last word and copy into wildspec (our local 
  51.    variable buffer for the call to wild) that word.  In this way 
  52.    wild need not deal with a far pointer.  We copy until we hit a 
  53.    space, tab or the end of the string.  Terminate the wildcard 
  54.    specification string with a null.  Reset count to what it was 
  55.    at the start of the word. */
  56.  
  57.         wildptr = wildspec;
  58.         source = swrdptr;
  59.         while ( *source != ' ' && *source != '\t' &&
  60.                 *source != '\0' ) *wildptr++ = *source++;
  61.         *wildptr = '\0';
  62.         count = savecount;
  63.  
  64. /* Call wild to expand the wild spec.  Put the answer where the
  65.    last destination word pointer was.  Update the count and the
  66.    destination pointer. */
  67.  
  68.         wildcount = wild (wildspec, dwrdptr, maxsize - count);
  69.         count += wildcount;
  70.         dest = dwrdptr + wildcount;
  71.         break;
  72.  
  73. /* dest now contains any previous arguments plus this one that
  74.    has been expanded by wild().  We're done with this case. */
  75.  
  76.       case ' ':
  77.       case '\t':
  78.  
  79. /* We hit a word terminator.  We update the source and 
  80.    destination word pointers to point to the next character.  
  81.    We also save the count as of the start of this word, in case  
  82.    we have to roll back to this position later. */
  83.    
  84.         swrdptr = source;
  85.         dwrdptr = dest;
  86.         savecount = count;
  87.         break;
  88.  
  89. /* Don't do anything for any other character.  Just move it from 
  90.    the source string to the destination string.  */
  91.  
  92.       default:
  93.         break;
  94.  
  95.     }  /* switch */
  96.  
  97.   }  /* while loop */
  98.  
  99.   return (count);                 /* Return the length of the new */
  100.                                   /* command line */
  101. }  /* expwild */
  102.  
  103.  
  104. int wild (wildspec, expand, maxsize)   /* general purpose routine */
  105.                                        /* that accepts an input */
  106.                                        /* wildcard spec wildspec */
  107.                                        /* and puts the resulting */
  108.                                        /* full file names, if any, */
  109.                                        /* in expand */
  110.  
  111. char *wildspec, *expand;
  112. int maxsize;
  113.  
  114. {
  115.   struct ffblk ffblk;           /* Special file block */
  116.   char drive[MAXDRIVE], dir[MAXDIR], name[MAXFILE], ext[MAXEXT];
  117.                                 /* these constants are in dir.h */
  118.                                 /* and reflect DOS size limits */
  119.   char *bufptr;
  120.   int size = 0;
  121.  
  122.   bufptr = expand;              /* Save our original pointer */
  123.  
  124. /* Split the file name into its fundamental components. We need 
  125.    the drive and directory information because the findfirst and 
  126.    findnext functions return only simple file names, and we want 
  127.    to return to our caller complete, unambiguous file pathnames. */
  128.     
  129.   fnsplit (wildspec, drive, dir, name, ext);
  130.  
  131. /* Find the first file that matches the input wildcard specification.
  132.    If none match, then copy the input string to the output output 
  133.    string and return the length of the resulting string. Note that 
  134.    another option is to return a null if the caller passes in a 
  135.    wildcard spec that matches no file.  We elected to let the caller 
  136.    handle the results in this case.  Both findfirst and findnext 
  137.    require a special file information block structure of type 
  138.    ffblk. */
  139.     
  140.   if (findfirst (wildspec, &ffblk, 0) != 0)
  141.   {
  142.     strncpy (expand, wildspec, maxsize);
  143.     return (strlen (expand));
  144.   } /* if no files match this wildcard specification */
  145.  
  146.   while (1)  /* loop until no more files match the wildcard spec */
  147.   {
  148.  
  149. /* Build up the complete file name from the optional drive name
  150.    and path name of the original wild file spec and the file name
  151.    found by either findfirst or findnext.  maxsize-size is always 
  152.    the total space remaining for the string.  */
  153.  
  154.     strncpy (bufptr, drive, maxsize - size);
  155.     strncat (bufptr, dir, maxsize - size);
  156.     strncat (bufptr, ffblk.ff_name, maxsize - size);
  157.  
  158.     size += strlen (bufptr);     /* Increase the string size to */
  159.                                  /* reflect the added file name */
  160.  
  161. /* If the string is now too long, roll back to the previous 
  162.    file name, deposit a null and return the string size.  bufptr 
  163.    still points to the start of this new file name, so rolling 
  164.    back is simple.  */
  165.  
  166.     if (size >= maxsize - 1)
  167.     {
  168.       *(bufptr - 1) = '\0';
  169.       return (strlen (expand));
  170.     } /* if the string is too long */
  171.  
  172. /* Update the pointer to move past the newly added file name and 
  173.    put a space after that file name.  Because we compared size to 
  174.    maxsize-1 above, we know there is room for the blank. */
  175.         
  176.     bufptr = expand + size++;
  177.     *bufptr++ = ' ';
  178.  
  179. /* Get the next file.  If there are no more, back up and put
  180.    a null over the space after the last name and return the size. */
  181.         
  182.     if (findnext (&ffblk) != 0)
  183.     {
  184.       *(bufptr - 1) = '\0';
  185.       return (size);
  186.     }  /* if there are no more files that match this spec */
  187.  
  188.   }  /* loop through all matching file names */
  189. }  /* wild */
  190.